package com.bawei.lib_storage.room

import android.util.Log
import com.bawei.lib_storage.room.entity.HistoryEntity
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

/**
 * 历史记录管理工具类
 */
object HistoryManager {
    
    private const val TAG = "HistoryManager"
    
    /**
     * 添加历史记录
     */
    suspend fun addHistory(
        userId: String,
        type: Int,
        title: String,
        primaryImg: String,
        content: String,
        authorImg: String,
        authorName: String,
        progress: Int = 0, // 新增，默认0
        lastPosition: Long = 0L, // 新增，默认0L
        videoId: String, // 新增，视频唯一标识
        videopath: String // 新增，视频播放地址
    ) {
        withContext(Dispatchers.IO) {
            try {
                Log.d(TAG, "开始添加历史记录:")
                Log.d(TAG, "- 用户ID: '$userId'")
                Log.d(TAG, "- 类型: $type")
                Log.d(TAG, "- 标题: '$title'")
                
                // 检查数据库是否初始化
                try {
                    val db = DBUtils.getDB()
                    Log.d(TAG, "数据库已初始化")
                } catch (e: Exception) {
                    Log.e(TAG, "数据库未初始化: ${e.message}")
                    return@withContext
                }
                
                val historyEntity = HistoryEntity(
                    id = 0, // Room会自动生成ID
                    userId = userId,
                    type = type,
                    title = title,
                    primaryImg = primaryImg,
                    content = content,
                    authorImg = authorImg,
                    authorName = authorName,
                    progress = progress, // 新增
                    lastPosition = lastPosition, // 新增
                    videoId = videoId, // 新增
                    videopath = videopath // 新增
                )
                
                // 检查是否已存在相同记录
                val existingHistory = DBUtils.getDB().historyDao().getAllByUserId(userId)
                val hasDuplicate = existingHistory.any { 
                    // 使用更宽松的去重条件：标题相同且用户相同，或者videoId相同且用户相同
                    (it.title == title && it.userId == userId) || 
                    (it.videoId == videoId && it.userId == userId && videoId.isNotEmpty())
                }
                
                if (hasDuplicate) {
                    Log.d(TAG, "历史记录已存在，跳过添加: $title")
                    // 如果存在重复记录，尝试更新现有记录的videoId（如果当前videoId不为空且现有记录videoId为空）
                    val existingRecord = existingHistory.find { 
                        it.title == title && it.userId == userId 
                    }
                    existingRecord?.let { record ->
                        if (record.videoId.isEmpty() && videoId.isNotEmpty()) {
                            // 更新现有记录的videoId
                            DBUtils.getDB().historyDao().updateVideoIdById(record.id, videoId)
                            Log.d(TAG, "更新历史记录videoId: ${record.id} -> $videoId")
                        }
                    }
                    return@withContext
                }
                
                DBUtils.getDB().historyDao().insertAll(historyEntity)
                Log.d(TAG, "添加历史记录成功: $title, 用户ID: $userId")
            } catch (e: Exception) {
                Log.e(TAG, "添加历史记录失败: ${e.message}", e)
                e.printStackTrace() // 打印完整的错误堆栈
            }
        }
    }
    
    /**
     * 添加视频历史记录
     */
    suspend fun addVideoHistory(
        userId: String,
        title: String,
        primaryImg: String,
        content: String,
        authorImg: String,
        authorName: String,
        progress: Int = 0, // 新增，默认0
        lastPosition: Long = 0L, // 新增，默认0L
        videoId: String, // 新增，视频唯一标识
        videopath: String // 新增，视频播放地址
    ) {
        addHistory(
            userId = userId,
            type = 1, // 1表示视频类型
            title = title,
            primaryImg = primaryImg,
            content = content,
            authorImg = authorImg,
            authorName = authorName,
            progress = progress, // 新增
            lastPosition = lastPosition, // 新增
            videoId = videoId, // 新增
            videopath = videopath // 新增
        )
    }
    
    /**
     * 获取历史记录列表（所有用户）
     */
    suspend fun getHistoryList(): List<HistoryEntity> {
        return withContext(Dispatchers.IO) {
            try {
                val list = DBUtils.getDB().historyDao().getAll()
                Log.d(TAG, "获取历史记录成功，数量: ${list.size}")
                list
            } catch (e: Exception) {
                Log.e(TAG, "获取历史记录失败: ${e.message}", e)
                emptyList()
            }
        }
    }
    
    /**
     * 根据用户ID获取历史记录列表
     */
    suspend fun getHistoryListByUserId(userId: String): List<HistoryEntity> {
        return withContext(Dispatchers.IO) {
            try {
                val list = DBUtils.getDB().historyDao().getAllByUserId(userId)
                Log.d(TAG, "获取用户历史记录成功，用户ID: $userId, 数量: ${list.size}")
                list
            } catch (e: Exception) {
                Log.e(TAG, "获取用户历史记录失败: ${e.message}", e)
                emptyList()
            }
        }
    }
    
    /**
     * 分页获取历史记录
     */
    suspend fun getHistoryListByPage(page: Int, pageSize: Int): List<HistoryEntity> {
        return withContext(Dispatchers.IO) {
            try {
                val list = DBUtils.getDB().historyDao().getAllByPage(page, pageSize)
                Log.d(TAG, "分页获取历史记录成功，页码: $page, 数量: ${list.size}")
                list
            } catch (e: Exception) {
                Log.e(TAG, "分页获取历史记录失败: ${e.message}", e)
                emptyList()
            }
        }
    }
    
    /**
     * 根据用户ID分页获取历史记录
     */
    suspend fun getHistoryListByUserIdAndPage(userId: String, page: Int, pageSize: Int): List<HistoryEntity> {
        return withContext(Dispatchers.IO) {
            try {
                val list = DBUtils.getDB().historyDao().getAllByUserIdAndPage(userId, page, pageSize)
                Log.d(TAG, "分页获取用户历史记录成功，用户ID: $userId, 页码: $page, 数量: ${list.size}")
                list
            } catch (e: Exception) {
                Log.e(TAG, "分页获取用户历史记录失败: ${e.message}", e)
                emptyList()
            }
        }
    }
    
    /**
     * 根据关键词搜索历史记录
     */
    suspend fun searchHistory(keywords: String): List<HistoryEntity> {
        return withContext(Dispatchers.IO) {
            try {
                val list = DBUtils.getDB().historyDao().getAllByKeyWords(keywords)
                Log.d(TAG, "搜索历史记录成功，关键词: $keywords, 数量: ${list.size}")
                list
            } catch (e: Exception) {
                Log.e(TAG, "搜索历史记录失败: ${e.message}", e)
                emptyList()
            }
        }
    }
    
    /**
     * 根据用户ID和关键词搜索历史记录
     */
    suspend fun searchHistoryByUserId(userId: String, keywords: String): List<HistoryEntity> {
        return withContext(Dispatchers.IO) {
            try {
                val list = DBUtils.getDB().historyDao().getAllByUserIdAndKeyWords(userId, keywords)
                Log.d(TAG, "搜索用户历史记录成功，用户ID: $userId, 关键词: $keywords, 数量: ${list.size}")
                list
            } catch (e: Exception) {
                Log.e(TAG, "搜索用户历史记录失败: ${e.message}", e)
                emptyList()
            }
        }
    }
    
    /**
     * 删除指定历史记录
     */
    suspend fun deleteHistory(historyEntity: HistoryEntity) {
        withContext(Dispatchers.IO) {
            try {
                DBUtils.getDB().historyDao().delete(historyEntity)
                Log.d(TAG, "删除历史记录成功: ${historyEntity.title}")
            } catch (e: Exception) {
                Log.e(TAG, "删除历史记录失败: ${e.message}", e)
            }
        }
    }
    
    /**
     * 清空所有历史记录
     */
    suspend fun clearAllHistory() {
        withContext(Dispatchers.IO) {
            try {
                DBUtils.getDB().historyDao().deleteAll()
                Log.d(TAG, "清空所有历史记录成功")
            } catch (e: Exception) {
                Log.e(TAG, "清空历史记录失败: ${e.message}", e)
            }
        }
    }
    
    /**
     * 清空指定用户的历史记录
     */
    suspend fun clearHistoryByUserId(userId: String) {
        withContext(Dispatchers.IO) {
            try {
                DBUtils.getDB().historyDao().deleteAllByUserId(userId)
                Log.d(TAG, "清空用户历史记录成功，用户ID: $userId")
            } catch (e: Exception) {
                Log.e(TAG, "清空用户历史记录失败: ${e.message}", e)
            }
        }
    }
    
    /**
     * 更新历史记录的观看进度
     */
    suspend fun updateHistoryProgress(id: Long, progress: Int) {
        withContext(Dispatchers.IO) {
            try {
                DBUtils.getDB().historyDao().updateProgressById(id, progress)
                Log.d(TAG, "更新历史记录进度成功: id=$id, progress=$progress")
            } catch (e: Exception) {
                Log.e(TAG, "更新历史记录进度失败: ${e.message}", e)
            }
        }
    }
    
    /**
     * 更新历史记录的观看进度（毫秒）
     */
    suspend fun updateLastPositionById(id: Long, lastPosition: Long) {
        withContext(Dispatchers.IO) {
            try {
                DBUtils.getDB().historyDao().updateLastPositionById(id, lastPosition)
            } catch (e: Exception) {
                Log.e(TAG, "更新lastPosition失败: ${e.message}", e)
            }
        }
    }
    
    /**
     * 根据videoId查找历史记录
     */
    suspend fun getHistoryByVideoId(videoId: String): HistoryEntity? {
        return withContext(Dispatchers.IO) {
            try {
                DBUtils.getDB().historyDao().getByVideoId(videoId)
            } catch (e: Exception) {
                Log.e(TAG, "按videoId查找历史记录失败: ${e.message}", e)
                null
            }
        }
    }
    
    /**
     * 清理重复的历史记录（保留最新的）
     */
    suspend fun cleanDuplicateHistory(userId: String) {
        withContext(Dispatchers.IO) {
            try {
                val allHistory = DBUtils.getDB().historyDao().getAllByUserId(userId)
                val groupedByTitle = allHistory.groupBy { it.title }
                
                groupedByTitle.forEach { (title, records) ->
                    if (records.size > 1) {
                        // 按ID排序，保留最新的（ID最大的）
                        val sortedRecords = records.sortedByDescending { it.id }
                        val toDelete = sortedRecords.drop(1) // 删除除最新记录外的所有记录
                        
                        toDelete.forEach { record ->
                            DBUtils.getDB().historyDao().delete(record)
                            Log.d(TAG, "删除重复历史记录: ${record.title}, ID: ${record.id}")
                        }
                    }
                }
                Log.d(TAG, "清理重复历史记录完成")
            } catch (e: Exception) {
                Log.e(TAG, "清理重复历史记录失败: ${e.message}", e)
            }
        }
    }
} 